home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / C / Applications / Portable Patmos / usr / include / ufs / fs.h < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-08  |  18.0 KB  |  448 lines  |  [TEXT/R*ch]
  1. /*
  2.  * Copyright (c) 1982, 1986 Regents of the University of California.
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice, this list of conditions and the following disclaimer.
  10.  * 2. Redistributions in binary form must reproduce the above copyright
  11.  *    notice, this list of conditions and the following disclaimer in the
  12.  *    documentation and/or other materials provided with the distribution.
  13.  * 3. All advertising materials mentioning features or use of this software
  14.  *    must display the following acknowledgement:
  15.  *    This product includes software developed by the University of
  16.  *    California, Berkeley and its contributors.
  17.  * 4. Neither the name of the University nor the names of its contributors
  18.  *    may be used to endorse or promote products derived from this software
  19.  *    without specific prior written permission.
  20.  *
  21.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31.  * SUCH DAMAGE.
  32.  *
  33.  *    from: @(#)fs.h    7.12 (Berkeley) 5/8/91
  34.  *    $Id: fs.h,v 1.4 1993/10/01 01:47:10 mycroft Exp $
  35.  */
  36.  
  37. #ifndef _UFS_FS_H_
  38. #define _UFS_FS_H_
  39.  
  40. /*
  41.  * Each disk drive contains some number of file systems.
  42.  * A file system consists of a number of cylinder groups.
  43.  * Each cylinder group has inodes and data.
  44.  *
  45.  * A file system is described by its super-block, which in turn
  46.  * describes the cylinder groups.  The super-block is critical
  47.  * data and is replicated in each cylinder group to protect against
  48.  * catastrophic loss.  This is done at `newfs' time and the critical
  49.  * super-block data does not change, so the copies need not be
  50.  * referenced further unless disaster strikes.
  51.  *
  52.  * For file system fs, the offsets of the various blocks of interest
  53.  * are given in the super block as:
  54.  *    [fs->fs_sblkno]        Super-block
  55.  *    [fs->fs_cblkno]        Cylinder group block
  56.  *    [fs->fs_iblkno]        Inode blocks
  57.  *    [fs->fs_dblkno]        Data blocks
  58.  * The beginning of cylinder group cg in fs, is given by
  59.  * the ``cgbase(fs, cg)'' macro.
  60.  *
  61.  * The first boot and super blocks are given in absolute disk addresses.
  62.  * The byte-offset forms are preferred, as they don't imply a sector size.
  63.  */
  64. #define BBSIZE        8192
  65. #define SBSIZE        8192
  66. #define    BBOFF        ((off_t)(0))
  67. #define    SBOFF        ((off_t)(BBOFF + BBSIZE))
  68. #define    BBLOCK        ((daddr_t)(0))
  69. #define    SBLOCK        ((daddr_t)(BBLOCK + BBSIZE / DEV_BSIZE))
  70.  
  71. /*
  72.  * Addresses stored in inodes are capable of addressing fragments
  73.  * of `blocks'. File system blocks of at most size MAXBSIZE can 
  74.  * be optionally broken into 2, 4, or 8 pieces, each of which is
  75.  * addressible; these pieces may be DEV_BSIZE, or some multiple of
  76.  * a DEV_BSIZE unit.
  77.  *
  78.  * Large files consist of exclusively large data blocks.  To avoid
  79.  * undue wasted disk space, the last data block of a small file may be
  80.  * allocated as only as many fragments of a large block as are
  81.  * necessary.  The file system format retains only a single pointer
  82.  * to such a fragment, which is a piece of a single large block that
  83.  * has been divided.  The size of such a fragment is determinable from
  84.  * information in the inode, using the ``blksize(fs, ip, lbn)'' macro.
  85.  *
  86.  * The file system records space availability at the fragment level;
  87.  * to determine block availability, aligned fragments are examined.
  88.  *
  89.  * The root inode is the root of the file system.
  90.  * Inode 0 can't be used for normal purposes and
  91.  * historically bad blocks were linked to inode 1,
  92.  * thus the root inode is 2. (inode 1 is no longer used for
  93.  * this purpose, however numerous dump tapes make this
  94.  * assumption, so we are stuck with it)
  95.  */
  96. #define    ROOTINO        ((ino_t)2)
  97.  
  98. /*
  99.  * MINBSIZE is the smallest allowable block size.
  100.  * In order to insure that it is possible to create files of size
  101.  * 2^32 with only two levels of indirection, MINBSIZE is set to 4096.
  102.  * MINBSIZE must be big enough to hold a cylinder group block,
  103.  * thus changes to (struct cg) must keep its size within MINBSIZE.
  104.  * Note that super blocks are always of size SBSIZE,
  105.  * and that both SBSIZE and MAXBSIZE must be >= MINBSIZE.
  106.  */
  107. #define MINBSIZE    4096
  108.  
  109. /*
  110.  * The path name on which the file system is mounted is maintained
  111.  * in fs_fsmnt. MAXMNTLEN defines the amount of space allocated in 
  112.  * the super block for this name.
  113.  * The limit on the amount of summary information per file system
  114.  * is defined by MAXCSBUFS. It is currently parameterized for a
  115.  * maximum of two million cylinders.
  116.  */
  117. #define MAXMNTLEN 512
  118. #define MAXCSBUFS 32
  119.  
  120. /*
  121.  * Per cylinder group information; summarized in blocks allocated
  122.  * from first cylinder group data blocks.  These blocks have to be
  123.  * read in from fs_csaddr (size fs_cssize) in addition to the
  124.  * super block.
  125.  *
  126.  * N.B. sizeof(struct csum) must be a power of two in order for
  127.  * the ``fs_cs'' macro to work (see below).
  128.  */
  129. struct csum {
  130.     long    cs_ndir;    /* number of directories */
  131.     long    cs_nbfree;    /* number of free blocks */
  132.     long    cs_nifree;    /* number of free inodes */
  133.     long    cs_nffree;    /* number of free frags */
  134. };
  135.  
  136. /*
  137.  * Super block for a file system.
  138.  */
  139. #define    FS_MAGIC    0x011954
  140. #define    FSOKAY        0x7c269d38
  141. #define    FS_CLEANFREQ    10
  142. struct    fs
  143. {
  144.     struct    fs *fs_link;        /* linked list of file systems */
  145.     struct    fs *fs_rlink;        /*     used for incore super blocks */
  146.     daddr_t    fs_sblkno;        /* addr of super-block in filesys */
  147.     daddr_t    fs_cblkno;        /* offset of cyl-block in filesys */
  148.     daddr_t    fs_iblkno;        /* offset of inode-blocks in filesys */
  149.     daddr_t    fs_dblkno;        /* offset of first data after cg */
  150.     long    fs_cgoffset;        /* cylinder group offset in cylinder */
  151.     long    fs_cgmask;        /* used to calc mod fs_ntrak */
  152.     time_t     fs_time;            /* last time written */
  153.     long    fs_size;        /* number of blocks in fs */
  154.     long    fs_dsize;        /* number of data blocks in fs */
  155.     long    fs_ncg;            /* number of cylinder groups */
  156.     long    fs_bsize;        /* size of basic blocks in fs */
  157.     long    fs_fsize;        /* size of frag blocks in fs */
  158.     long    fs_frag;        /* number of frags in a block in fs */
  159. /* these are configuration parameters */
  160.     long    fs_minfree;        /* minimum percentage of free blocks */
  161.     long    fs_rotdelay;        /* num of ms for optimal next block */
  162.     long    fs_rps;            /* disk revolutions per second */
  163. /* these fields can be computed from the others */
  164.     long    fs_bmask;        /* ``blkoff'' calc of blk offsets */
  165.     long    fs_fmask;        /* ``fragoff'' calc of frag offsets */
  166.     long    fs_bshift;        /* ``lblkno'' calc of logical blkno */
  167.     long    fs_fshift;        /* ``numfrags'' calc number of frags */
  168. /* these are configuration parameters */
  169.     long    fs_maxcontig;        /* max number of contiguous blks */
  170.     long    fs_maxbpg;        /* max number of blks per cyl group */
  171. /* these fields can be computed from the others */
  172.     long    fs_fragshift;        /* block to frag shift */
  173.     long    fs_fsbtodb;        /* fsbtodb and dbtofsb shift constant */
  174.     long    fs_sbsize;        /* actual size of super block */
  175.     long    fs_csmask;        /* csum block offset */
  176.     long    fs_csshift;        /* csum block number */
  177.     long    fs_nindir;        /* value of NINDIR */
  178.     long    fs_inopb;        /* value of INOPB */
  179.     long    fs_nspf;        /* value of NSPF */
  180. /* yet another configuration parameter */
  181.     long    fs_optim;        /* optimization preference, see below */
  182. /* these fields are derived from the hardware */
  183.     long    fs_npsect;        /* # sectors/track including spares */
  184.     long    fs_interleave;        /* hardware sector interleave */
  185.     long    fs_trackskew;        /* sector 0 skew, per track */
  186.     long    fs_headswitch;        /* head switch time, usec */
  187.     long    fs_trkseek;        /* track-to-track seek, usec */
  188. /* sizes determined by number of cylinder groups and their sizes */
  189.     daddr_t fs_csaddr;        /* blk addr of cyl grp summary area */
  190.     long    fs_cssize;        /* size of cyl grp summary area */
  191.     long    fs_cgsize;        /* cylinder group size */
  192. /* these fields are derived from the hardware */
  193.     long    fs_ntrak;        /* tracks per cylinder */
  194.     long    fs_nsect;        /* sectors per track */
  195.     long      fs_spc;           /* sectors per cylinder */
  196. /* this comes from the disk driver partitioning */
  197.     long    fs_ncyl;           /* cylinders in file system */
  198. /* these fields can be computed from the others */
  199.     long    fs_cpg;            /* cylinders per group */
  200.     long    fs_ipg;            /* inodes per group */
  201.     long    fs_fpg;            /* blocks per group * fs_frag */
  202. /* this data must be re-computed after crashes */
  203.     struct    csum fs_cstotal;    /* cylinder summary information */
  204. /* these fields are cleared at mount time */
  205.     char       fs_fmod;            /* super block modified flag */
  206.     char       fs_clean;            /* file system is clean flag */
  207.     char       fs_ronly;           /* mounted read-only flag */
  208.     char       fs_flags;           /* currently unused flag */
  209.     char    fs_fsmnt[MAXMNTLEN];    /* name mounted on */
  210. /* these fields retain the current block allocation info */
  211.     long    fs_cgrotor;        /* last cg searched */
  212.     struct    csum *fs_csp[MAXCSBUFS];/* list of fs_cs info buffers */
  213.     long    fs_cpc;            /* cyl per cycle in postbl */
  214.     short    fs_opostbl[16][8];    /* old rotation block list head */
  215.     long    fs_sparecon[55];    /* reserved for future constants */
  216.     long    fs_state;        /* validate fs_clean field */
  217.     quad    fs_qbmask;        /* ~fs_bmask - for use with quad size */
  218.     quad    fs_qfmask;        /* ~fs_fmask - for use with quad size */
  219.     long    fs_postblformat;    /* format of positional layout tables */
  220.     long    fs_nrpos;        /* number of rotaional positions */
  221.     long    fs_postbloff;        /* (short) rotation block list head */
  222.     long    fs_rotbloff;        /* (u_char) blocks for each rotation */
  223.     long    fs_magic;        /* magic number */
  224.     u_char    fs_space[1];        /* list of blocks for each rotation */
  225. /* actually longer */
  226. };
  227. /*
  228.  * Preference for optimization.
  229.  */
  230. #define FS_OPTTIME    0    /* minimize allocation time */
  231. #define FS_OPTSPACE    1    /* minimize disk fragmentation */
  232.  
  233. /*
  234.  * Rotational layout table format types
  235.  */
  236. #define FS_42POSTBLFMT        -1    /* 4.2BSD rotational table format */
  237. #define FS_DYNAMICPOSTBLFMT    1    /* dynamic rotational table format */
  238. /*
  239.  * Macros for access to superblock array structures
  240.  */
  241. #define fs_postbl(fs, cylno) \
  242.     (((fs)->fs_postblformat == FS_42POSTBLFMT) \
  243.     ? ((fs)->fs_opostbl[cylno]) \
  244.     : ((short *)((char *)(fs) + (fs)->fs_postbloff) + (cylno) * (fs)->fs_nrpos))
  245. #define fs_rotbl(fs) \
  246.     (((fs)->fs_postblformat == FS_42POSTBLFMT) \
  247.     ? ((fs)->fs_space) \
  248.     : ((u_char *)((char *)(fs) + (fs)->fs_rotbloff)))
  249.  
  250. /*
  251.  * Convert cylinder group to base address of its global summary info.
  252.  *
  253.  * N.B. This macro assumes that sizeof(struct csum) is a power of two.
  254.  */
  255. #define fs_cs(fs, indx) \
  256.     fs_csp[(indx) >> (fs)->fs_csshift][(indx) & ~(fs)->fs_csmask]
  257.  
  258. /*
  259.  * Cylinder group block for a file system.
  260.  */
  261. #define    CG_MAGIC    0x090255
  262. struct    cg {
  263.     struct    cg *cg_link;        /* linked list of cyl groups */
  264.     long    cg_magic;        /* magic number */
  265.     time_t    cg_time;        /* time last written */
  266.     long    cg_cgx;            /* we are the cgx'th cylinder group */
  267.     short    cg_ncyl;        /* number of cyl's this cg */
  268.     short    cg_niblk;        /* number of inode blocks this cg */
  269.     long    cg_ndblk;        /* number of data blocks this cg */
  270.     struct    csum cg_cs;        /* cylinder summary information */
  271.     long    cg_rotor;        /* position of last used block */
  272.     long    cg_frotor;        /* position of last used frag */
  273.     long    cg_irotor;        /* position of last used inode */
  274.     long    cg_frsum[MAXFRAG];    /* counts of available frags */
  275.     long    cg_btotoff;        /* (long) block totals per cylinder */
  276.     long    cg_boff;        /* (short) free block positions */
  277.     long    cg_iusedoff;        /* (char) used inode map */
  278.     long    cg_freeoff;        /* (u_char) free block map */
  279.     long    cg_nextfreeoff;        /* (u_char) next available space */
  280.     long    cg_sparecon[16];    /* reserved for future use */
  281.     u_char    cg_space[1];        /* space for cylinder group maps */
  282. /* actually longer */
  283. };
  284. /*
  285.  * Macros for access to cylinder group array structures
  286.  */
  287. #define cg_blktot(cgp) \
  288.     (((cgp)->cg_magic != CG_MAGIC) \
  289.     ? (((struct ocg *)(cgp))->cg_btot) \
  290.     : ((long *)((char *)(cgp) + (cgp)->cg_btotoff)))
  291. #define cg_blks(fs, cgp, cylno) \
  292.     (((cgp)->cg_magic != CG_MAGIC) \
  293.     ? (((struct ocg *)(cgp))->cg_b[cylno]) \
  294.     : ((short *)((char *)(cgp) + (cgp)->cg_boff) + (cylno) * (fs)->fs_nrpos))
  295. #define cg_inosused(cgp) \
  296.     (((cgp)->cg_magic != CG_MAGIC) \
  297.     ? (((struct ocg *)(cgp))->cg_iused) \
  298.     : ((char *)((char *)(cgp) + (cgp)->cg_iusedoff)))
  299. #define cg_blksfree(cgp) \
  300.     (((cgp)->cg_magic != CG_MAGIC) \
  301.     ? (((struct ocg *)(cgp))->cg_free) \
  302.     : ((u_char *)((char *)(cgp) + (cgp)->cg_freeoff)))
  303. #define cg_chkmagic(cgp) \
  304.     ((cgp)->cg_magic == CG_MAGIC || ((struct ocg *)(cgp))->cg_magic == CG_MAGIC)
  305.  
  306. /*
  307.  * The following structure is defined
  308.  * for compatibility with old file systems.
  309.  */
  310. struct    ocg {
  311.     struct    ocg *cg_link;        /* linked list of cyl groups */
  312.     struct    ocg *cg_rlink;        /*     used for incore cyl groups */
  313.     time_t    cg_time;        /* time last written */
  314.     long    cg_cgx;            /* we are the cgx'th cylinder group */
  315.     short    cg_ncyl;        /* number of cyl's this cg */
  316.     short    cg_niblk;        /* number of inode blocks this cg */
  317.     long    cg_ndblk;        /* number of data blocks this cg */
  318.     struct    csum cg_cs;        /* cylinder summary information */
  319.     long    cg_rotor;        /* position of last used block */
  320.     long    cg_frotor;        /* position of last used frag */
  321.     long    cg_irotor;        /* position of last used inode */
  322.     long    cg_frsum[8];        /* counts of available frags */
  323.     long    cg_btot[32];        /* block totals per cylinder */
  324.     short    cg_b[32][8];        /* positions of free blocks */
  325.     char    cg_iused[256];        /* used inode map */
  326.     long    cg_magic;        /* magic number */
  327.     u_char    cg_free[1];        /* free block map */
  328. /* actually longer */
  329. };
  330.  
  331. /*
  332.  * Turn file system block numbers into disk block addresses.
  333.  * This maps file system blocks to device size blocks.
  334.  */
  335. #define fsbtodb(fs, b)    ((b) << (fs)->fs_fsbtodb)
  336. #define    dbtofsb(fs, b)    ((b) >> (fs)->fs_fsbtodb)
  337.  
  338. /*
  339.  * Cylinder group macros to locate things in cylinder groups.
  340.  * They calc file system addresses of cylinder group data structures.
  341.  */
  342. #define    cgbase(fs, c)    ((daddr_t)((fs)->fs_fpg * (c)))
  343. #define cgstart(fs, c) \
  344.     (cgbase(fs, c) + (fs)->fs_cgoffset * ((c) & ~((fs)->fs_cgmask)))
  345. #define    cgsblock(fs, c)    (cgstart(fs, c) + (fs)->fs_sblkno)    /* super blk */
  346. #define    cgtod(fs, c)    (cgstart(fs, c) + (fs)->fs_cblkno)    /* cg block */
  347. #define    cgimin(fs, c)    (cgstart(fs, c) + (fs)->fs_iblkno)    /* inode blk */
  348. #define    cgdmin(fs, c)    (cgstart(fs, c) + (fs)->fs_dblkno)    /* 1st data */
  349.  
  350. /*
  351.  * Macros for handling inode numbers:
  352.  *     inode number to file system block offset.
  353.  *     inode number to cylinder group number.
  354.  *     inode number to file system block address.
  355.  */
  356. #define    itoo(fs, x)    ((x) % INOPB(fs))
  357. #define    itog(fs, x)    ((x) / (fs)->fs_ipg)
  358. #define    itod(fs, x) \
  359.     ((daddr_t)(cgimin(fs, itog(fs, x)) + \
  360.     (blkstofrags((fs), (((x) % (fs)->fs_ipg) / INOPB(fs))))))
  361.  
  362. /*
  363.  * Give cylinder group number for a file system block.
  364.  * Give cylinder group block number for a file system block.
  365.  */
  366. #define    dtog(fs, d)    ((d) / (fs)->fs_fpg)
  367. #define    dtogd(fs, d)    ((d) % (fs)->fs_fpg)
  368.  
  369. /*
  370.  * Extract the bits for a block from a map.
  371.  * Compute the cylinder and rotational position of a cyl block addr.
  372.  */
  373. #define blkmap(fs, map, loc) \
  374.     (((map)[(loc) / NBBY] >> ((loc) % NBBY)) & (0xff >> (NBBY - (fs)->fs_frag)))
  375. #define cbtocylno(fs, bno) \
  376.     ((bno) * NSPF(fs) / (fs)->fs_spc)
  377. #define cbtorpos(fs, bno) \
  378.     (((bno) * NSPF(fs) % (fs)->fs_spc / (fs)->fs_nsect * (fs)->fs_trackskew + \
  379.      (bno) * NSPF(fs) % (fs)->fs_spc % (fs)->fs_nsect * (fs)->fs_interleave) % \
  380.      (fs)->fs_nsect * (fs)->fs_nrpos / (fs)->fs_npsect)
  381.  
  382. /*
  383.  * The following macros optimize certain frequently calculated
  384.  * quantities by using shifts and masks in place of divisions
  385.  * modulos and multiplications.
  386.  */
  387. #define blkoff(fs, loc)        /* calculates (loc % fs->fs_bsize) */ \
  388.     ((loc) & ~(fs)->fs_bmask)
  389. #define fragoff(fs, loc)    /* calculates (loc % fs->fs_fsize) */ \
  390.     ((loc) & ~(fs)->fs_fmask)
  391. #define lblktosize(fs, blk)    /* calculates (blk * fs->fs_bsize) */ \
  392.     ((blk) << (fs)->fs_bshift)
  393. #define lblkno(fs, loc)        /* calculates (loc / fs->fs_bsize) */ \
  394.     ((loc) >> (fs)->fs_bshift)
  395. #define numfrags(fs, loc)    /* calculates (loc / fs->fs_fsize) */ \
  396.     ((loc) >> (fs)->fs_fshift)
  397. #define blkroundup(fs, size)    /* calculates roundup(size, fs->fs_bsize) */ \
  398.     (((size) + (fs)->fs_bsize - 1) & (fs)->fs_bmask)
  399. #define fragroundup(fs, size)    /* calculates roundup(size, fs->fs_fsize) */ \
  400.     (((size) + (fs)->fs_fsize - 1) & (fs)->fs_fmask)
  401. #define fragstoblks(fs, frags)    /* calculates (frags / fs->fs_frag) */ \
  402.     ((frags) >> (fs)->fs_fragshift)
  403. #define blkstofrags(fs, blks)    /* calculates (blks * fs->fs_frag) */ \
  404.     ((blks) << (fs)->fs_fragshift)
  405. #define fragnum(fs, fsb)    /* calculates (fsb % fs->fs_frag) */ \
  406.     ((fsb) & ((fs)->fs_frag - 1))
  407. #define blknum(fs, fsb)        /* calculates rounddown(fsb, fs->fs_frag) */ \
  408.     ((fsb) &~ ((fs)->fs_frag - 1))
  409.  
  410. /*
  411.  * Determine the number of available frags given a
  412.  * percentage to hold in reserve
  413.  */
  414. #define freespace(fs, percentreserved) \
  415.     (blkstofrags((fs), (fs)->fs_cstotal.cs_nbfree) + \
  416.     (fs)->fs_cstotal.cs_nffree - ((fs)->fs_dsize * (percentreserved) / 100))
  417.  
  418. /*
  419.  * Determining the size of a file block in the file system.
  420.  */
  421. #define blksize(fs, ip, lbn) \
  422.     (((lbn) >= NDADDR || (ip)->i_size >= ((lbn) + 1) << (fs)->fs_bshift) \
  423.         ? (fs)->fs_bsize \
  424.         : (fragroundup(fs, blkoff(fs, (ip)->i_size))))
  425. #define dblksize(fs, dip, lbn) \
  426.     (((lbn) >= NDADDR || (dip)->di_size >= ((lbn) + 1) << (fs)->fs_bshift) \
  427.         ? (fs)->fs_bsize \
  428.         : (fragroundup(fs, blkoff(fs, (dip)->di_size))))
  429.  
  430. /*
  431.  * Number of disk sectors per block; assumes DEV_BSIZE byte sector size.
  432.  */
  433. #define    NSPB(fs)    ((fs)->fs_nspf << (fs)->fs_fragshift)
  434. #define    NSPF(fs)    ((fs)->fs_nspf)
  435.  
  436. /*
  437.  * INOPB is the number of inodes in a secondary storage block.
  438.  */
  439. #define    INOPB(fs)    ((fs)->fs_inopb)
  440. #define    INOPF(fs)    ((fs)->fs_inopb >> (fs)->fs_fragshift)
  441.  
  442. /*
  443.  * NINDIR is the number of indirects in a file system block.
  444.  */
  445. #define    NINDIR(fs)    ((fs)->fs_nindir)
  446.  
  447. #endif /* !_UFS_FS_H_ */
  448.